SDWebImage 图片缓存

这篇文章我将接着节讲述关于 SDWebImage 图片下载后处理方式，缓存进行讲解。

经过上面我们可以知道 SDWebImage 是可以从远程的服务器加载图片，然后在UIImageView 上进行显示。但是你有想过 SDWebImage 到底是什么呢？

在使用时我们知道需要导入包：UIImageView+WebCache.h 我们可以根据这看出 SDWebImage 是一个 UIImageView 的分类，使用 Category 进行分装的类。下面列出 SDWebImage 可以实现的功能：

• 提供 UIImageView 的一个分类，可以对图片进行异步加载和缓存管理
• 一步内存 & 磁盘管理 & 自动对过期的缓存进行相关的处理
• 一个一步图片的加载器
• 支持 GIF 的图片加载
• 后台对图片进行解压处理
• 确保同意 URL 的图片不会被数次加载
• 确保虚假的 URL 不会被反复加载
• 确保下载和缓存时主线程不会被阻塞
• 优良使用性能
• 采用 GCD 可以采用并行处理，iOS 5.0 的 ARC 自动计数原则
• 支持 Arm64 (64位 CPU 处理)

本篇博客是在 SDWebImage 的图片加载基础之上进行探索，下面我们就来看下 SDWebImage 是如何实现对图片实行缓存处理。

实例

SDImageCache 是图片下载后内存缓存管理和磁盘缓存管理的类，不过还是我们最常见的单例模式 sharedImageCache 来进行得到实例。默认的缓存空间上是 default ，如果自己看着不怎么好的话可以自己进行相关的空间申请。下面是 SDWebCache 的简介：

+ (SDImageCache *)sharedImageCache {
    static dispatch_once_t once;
    static id instance;
    dispatch_once(&once, ^{
        instance = [self new];
    });
    return instance;
}

这里使用 dispatch_once 的形式每次开启一个线程，这样可以防止多个单例进行同时的初始化。

- (id)init {
    return [self initWithNamespace:@"default"];
}

- (id)initWithNamespace:(NSString *)ns {
    NSString *path = [self makeDiskCachePath:ns];
    return [self initWithNamespace:ns diskCacheDirectory:path];
}

- (id)initWithNamespace:(NSString *)ns diskCacheDirectory:(NSString *)directory {
    if ((self = [super init])) {
        NSString *fullNamespace = [@"com.hackemist. `SDWebImageCache." stringByAppendingString:ns];

     // initialise PNG signature data
     kPNGSignatureData = [NSData dataWithBytes:kPNGSignatureBytes length:8];

     // Create IO serial queue
     _ioQueue = dispatch_queue_create("com.hackemist. SDWebImageCache", DISPATCH_QUEUE_SERIAL);

     // Init default values
     _maxCacheAge = kDefaultCacheMaxCacheAge;

     // Init the memory cache
     _memCache = [[AutoPurgeCache alloc] init];
     _memCache.name = fullNamespace;

     // Init the disk cache
     if (directory != nil) {
         _diskCachePath = [directory stringByAppendingPathComponent:fullNamespace];
     } else {
         NSString *path = [self makeDiskCachePath:ns];
         _diskCachePath = path;
     }

     // Set decompression to YES
     _shouldDecompressImages = YES;

     // memory cache enabled
     _shouldCacheImagesInMemory = YES;

     // Disable iCloud
     _shouldDisableiCloud = YES;

     dispatch_sync(_ioQueue, ^{
         _fileManager = [NSFileManager new];
     });

#if TARGET_OS_IPHONE
     // Subscribe to app events
     [[NSNotificationCenter defaultCenter] addObserver:self
                                              selector:@selector(clearMemory)
                                                  name:UIApplicationDidReceiveMemoryWarningNotification
                                                object:nil];

     [[NSNotificationCenter defaultCenter] addObserver:self
                                              selector:@selector(cleanDisk)
                                                  name:UIApplicationWillTerminateNotification
                                                object:nil];

     [[NSNotificationCenter defaultCenter] addObserver:self
                                              selector:@selector(backgroundCleanDisk)
                                                  name:UIApplicationDidEnterBackgroundNotification
                                                object:nil];
#endif
  }

  return self;
}

上面我们可以看出在我们使用 init 来进行初始化缓存空间，紧接着就调用 initWithNamespace: & initWithNamespace: diskCacheDirectory:来进一步对磁盘进行缓存空间的初始化。

内存缓存类

@interface AutoPurgeCache : NSCache

@end

@implementation AutoPurgeCache

- (id)init
{
    self = [super init];
    if (self) {
        [[NSNotificationCenter defaultCenter] addObserver:self selector:@selector(removeAllObjects) name:UIApplicationDidReceiveMemoryWarningNotification object:nil];
    }
    return self;
}

- (void)dealloc
{
    [[NSNotificationCenter defaultCenter] removeObserver:self name:UIApplicationDidReceiveMemoryWarningNotification object:nil];

}

@end

上面我们可以看出在缓存过程中我们采用的是 NSCache 的子类 AutoPurgeCache 进行线管的缓存处理，但是我们也可以直接使用 NSdictionary 来进行处理，为什么不使用呢？后面我将会讲出😸。返回上面，我们可以看出在缓存时我们采用注册和监听的模式对缓存的内存监听，一旦缓存数据达到临界点就要条用 removeAllObjects。这里有关于方法在运行时编译情况下的过程。

在缓存过程中我们使用的是 NSCache 而不是用 NSDictionary 呢，下面我们看下NSCache 的优点：

• 自动删减功能
• 线程安全
• 不会拷贝健
  

基于上面 NSCache 的特点选着使用 NSCache 是更加易于对缓存的管理

缓存在APP周期的设置

在应用开发对内容缓存的过程我们也可以参考下面缓存的处理机制，这也对我们 App 的性能会有比较大的提升。下面按照 App 的分为：内存警告、程序终止和后台三种情况实现缓存策略。

内存警告

在我们使用 SDWebImage 过程时程序一直都会对我们访的图片进行相关缓存处理，但是当我们缓存较大时就会产生警告

- (void)clearMemory {
    [self.memCache removeAllObjects];
}

上面是我们注册发现内存过大需要调用的方法。

程序终止

- (void)cleanDisk {
    [self cleanDiskWithCompletionBlock:nil];
}

- (void)cleanDiskWithCompletionBlock:( SDWebImageNoParamsBlock)completionBlock {
    dispatch_async(self.ioQueue, ^{
        NSURL *diskCacheURL = [NSURL fileURLWithPath:self.diskCachePath isDirectory:YES];
        NSArray *resourceKeys = @[NSURLIsDirectoryKey, NSURLContentModificationDateKey, NSURLTotalFileAllocatedSizeKey];

// This enumerator prefetches useful properties for our cache files.
      NSDirectoryEnumerator *fileEnumerator = [_fileManager enumeratorAtURL:diskCacheURL
                                                 includingPropertiesForKeys:resourceKeys
                                                                    options:NSDirectoryEnumerationSkipsHiddenFiles
                                                               errorHandler:NULL];

      NSDate *expirationDate = [NSDate dateWithTimeIntervalSinceNow:-self.maxCacheAge];
      NSMutableDictionary *cacheFiles = [NSMutableDictionary dictionary];
      NSUInteger currentCacheSize = 0;

      // Enumerate all of the files in the cache directory.  This loop has two purposes:
      //
      //  1. Removing files that are older than the expiration date.
      //  2. Storing file attributes for the size-based cleanup pass.
      NSMutableArray *urlsToDelete = [[NSMutableArray alloc] init];
      for (NSURL *fileURL in fileEnumerator) {
          NSDictionary *resourceValues = [fileURL resourceValuesForKeys:resourceKeys error:NULL];

          // Skip directories.
          if ([resourceValues[NSURLIsDirectoryKey] boolValue]) {
              continue;
          }

          // Remove files that are older than the expiration date;
          NSDate *modificationDate = resourceValues[NSURLContentModificationDateKey];
          if ([[modificationDate laterDate:expirationDate] isEqualToDate:expirationDate]) {
              [urlsToDelete addObject:fileURL];
              continue;
          }

          // Store a reference to this file and account for its total size.
          NSNumber *totalAllocatedSize = resourceValues[NSURLTotalFileAllocatedSizeKey];
          currentCacheSize += [totalAllocatedSize unsignedIntegerValue];
          [cacheFiles setObject:resourceValues forKey:fileURL];
      }
      
      for (NSURL *fileURL in urlsToDelete) {
          [_fileManager removeItemAtURL:fileURL error:nil];
      }

      // If our remaining disk cache exceeds a configured maximum size, perform a second
      // size-based cleanup pass.  We delete the oldest files first.
      if (self.maxCacheSize > 0 && currentCacheSize > self.maxCacheSize) {
          // Target half of our maximum cache size for this cleanup pass.
          const NSUInteger desiredCacheSize = self.maxCacheSize / 2;

        // Sort the remaining cache files by their last modification time (oldest first).
        NSArray *sortedFiles = [cacheFiles keysSortedByValueWithOptions:NSSortConcurrent
                                                        usingComparator:^NSComparisonResult(id obj1, id obj2) {
                                                            return [obj1[NSURLContentModificationDateKey] compare:obj2[NSURLContentModificationDateKey]];
                                                        }];

        // Delete files until we fall below our desired cache size.
        for (NSURL *fileURL in sortedFiles) {
            if ([_fileManager removeItemAtURL:fileURL error:nil]) {
                NSDictionary *resourceValues = cacheFiles[fileURL];
                NSNumber *totalAllocatedSize = resourceValues[NSURLTotalFileAllocatedSizeKey];
                currentCacheSize -= [totalAllocatedSize unsignedIntegerValue];

                if (currentCacheSize < desiredCacheSize) {
                    break;
                }
            }
          }
      }
      if (completionBlock) {
          dispatch_async(dispatch_get_main_queue(), ^{
              completionBlock();
          });
      }
  });
}

从上面我们可以看出当收到 UIApplicationWillTerminateNotification 时，SDImageCache 将会使用 ioQueue 异步地清理磁盘缓存。

清除过程的逻辑如下：

先清除已超过最大缓存时间的缓存文件（最大缓存时间默认为一星期） 在第一轮清除的过程中保存文件属性，特别是缓存文件大小
在第一轮清除后，如果设置了最大缓存并且保留下来的磁盘缓存文件仍然超过了配置的最大缓存，那么进行第二轮以大小为基础的清除。 首先删除最老的文件，直到达到期望的总的缓存大小，即最大缓存的一半。

程序进入后台

- (void)backgroundCleanDisk {
    Class UIApplicationClass = NSClassFromString(@"UIApplication");
    if(!UIApplicationClass || ![UIApplicationClass respondsToSelector:@selector(sharedApplication)]) {
        return;
    }
    UIApplication *application = [UIApplication performSelector:@selector(sharedApplication)];
    __block UIBackgroundTaskIdentifier bgTask = [application beginBackgroundTaskWithExpirationHandler:^{
        // Clean up any unfinished task business by marking where you
        // stopped or ending the task outright.
        [application endBackgroundTask:bgTask];
        bgTask = UIBackgroundTaskInvalid;
    }];

   // Start the long-running task and return immediately.
   [self cleanDiskWithCompletionBlock:^{
       [application endBackgroundTask:bgTask];
       bgTask = UIBackgroundTaskInvalid;
   }];
}

当收到 UIApplicationDidEnterBackgroundNotification 时，在手机系统后台进行如上面描述的异步磁盘缓存清理。这里利用 Objective－C 的动态语言特性，得到UIApplication 的单例 sharedApplication ，使用 sharedApplication 开启后台任务 cleanDiskWithCompletionBlock:

查询图片

- (NSOperation *)queryDiskCacheForKey:(NSString *)key done:( SDWebImageQueryCompletedBlock)doneBlock {
   if (!doneBlock) {
       return nil;
   }

   if (!key) {
       doneBlock(nil, SDImageCacheTypeNone);
       return nil;
   }

   // First check the in-memory cache...
   UIImage *image = [self imageFromMemoryCacheForKey:key];
   if (image) {
       doneBlock(image, SDImageCacheTypeMemory);
       return nil;
   }

   NSOperation *operation = [NSOperation new];
   dispatch_async(self.ioQueue, ^{
       if (operation.isCancelled) {
           return;
       }

       @autoreleasepool {
           UIImage *diskImage = [self diskImageForKey:key];
           if (diskImage && self.shouldCacheImagesInMemory) {
               NSUInteger cost = SDCacheCostForImage(diskImage);
               [self.memCache setObject:diskImage forKey:key cost:cost];
           }

           dispatch_async(dispatch_get_main_queue(), ^{
               doneBlock(diskImage, SDImageCacheTypeDisk);
           });
       }
   });

   return operation;
}

查询缓存，默认使用方法 queryDiskCacheForKey:done:，如果此方法返回nil，则说明缓存中现在还没有这张照片，因此你需要得到并缓存这张图片。缓存 key 是缓存图片的程序唯一的标识符，一般使用图片的完整 URL。

如果不想 SDImageCache 查询磁盘缓存，你可以调用另一个方法：imageFromMemoryCacheForKey:。

返回值为 NSOpration，单独使用 SDImageCache 没用，但是使用 SDWebImageManager 就可以对多个任务的优先级、依赖，并且可以取消。

自定义@autoreleasepool，autoreleasepool代码段里面有大量的内存消耗操作，自定义autoreleasepool可以及时地释放掉内存。

- (NSString *)cachePathForKey:(NSString *)key inPath:(NSString *)path {
    NSString *filename = [self cachedFileNameForKey:key];
    return [path stringByAppendingPathComponent:filename];
}

- (NSString *)defaultCachePathForKey:(NSString *)key {
    return [self cachePathForKey:key inPath:self.diskCachePath];
}

#pragma mark SDImageCache (private)

- (NSString *)cachedFileNameForKey:(NSString *)key {
    const char *str = [key UTF8String];
    if (str == NULL) {
        str = "";
    }
    unsigned char r[CC_MD5_DIGEST_LENGTH];
    CC_MD5(str, (CC_LONG)strlen(str), r);
    NSString *filename = [NSString stringWithFormat:@"%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%@",
                          r[0], r[1], r[2], r[3], r[4], r[5], r[6], r[7], r[8], r[9], r[10],
                          r[11], r[12], r[13], r[14], r[15], [[key pathExtension] isEqualToString:@""] ? @"" : [NSString stringWithFormat:@".%@", [key pathExtension]]];

    return filename;
}

- (NSData *)diskImageDataBySearchingAllPathsForKey:(NSString *)key {
    NSString *defaultPath = [self defaultCachePathForKey:key];
    NSData *data = [NSData dataWithContentsOfFile:defaultPath];
    if (data) {
        return data;
    }

    // fallback because of https://github.com/rs/ `SDWebImage` /pull/976 that added the extension to the disk file name
    // checking the key with and without the extension
    data = [NSData dataWithContentsOfFile:[defaultPath stringByDeletingPathExtension]];
    if (data) {
        return data;
    }

    NSArray *customPaths = [self.customPaths copy];
    for (NSString *path in customPaths) {
        NSString *filePath = [self cachePathForKey:key inPath:path];
        NSData *imageData = [NSData dataWithContentsOfFile:filePath];
        if (imageData) {
            return imageData;
        }

        // fallback because of https://github.com/rs/ `SDWebImage` /pull/976 that added the extension to the disk file name
        // checking the key with and without the extension
        imageData = [NSData dataWithContentsOfFile:[filePath stringByDeletingPathExtension]];
        if (imageData) {
            return imageData;
        }
    }

    return nil;
}

上面代码段是从磁盘获取图片的代码。得到图片对应的 UIData 后，还要经过如下步骤，才能返回对应的图片：

• 根据图片的不同种类，生成对应的 UIImage
• 根据 key 值，调整 image 的 scale 值
• 如果设置图片需要解压缩，则还需对 UIImage 进行解码

下面是MD5的加密方式

- (NSString *)cachedFileNameForKey:(NSString *)key {
    const char *str = [key UTF8String];
    if (str == NULL) {
        str = "";
    }
    unsigned char r[CC_MD5_DIGEST_LENGTH];
    CC_MD5(str, (CC_LONG)strlen(str), r);
    NSString *filename = [NSString stringWithFormat:@"%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%@",
                          r[0], r[1], r[2], r[3], r[4], r[5], r[6], r[7], r[8], r[9], r[10],
                          r[11], r[12], r[13], r[14], r[15], [[key pathExtension] isEqualToString:@""] ? @"" : [NSString stringWithFormat:@".%@", [key pathExtension]]];

    return filename;
}

图片的保存

- (void)storeImage:(UIImage *)image recalculateFromImage:(BOOL)recalculate imageData:(NSData *)imageData forKey:(NSString *)key toDisk:(BOOL)toDisk {
    if (!image || !key) {
        return;
    }
    // if memory cache is enabled
    if (self.shouldCacheImagesInMemory) {
        NSUInteger cost = SDCacheCostForImage(image);
        [self.memCache setObject:image forKey:key cost:cost];
    }

    if (toDisk) {
        dispatch_async(self.ioQueue, ^{
            NSData *data = imageData;

            if (image && (recalculate || !data)) {
#if TARGET_OS_IPHONE
                // We need to determine if the image is a PNG or a JPEG
                // PNGs are easier to detect because they have a unique signature (http://www.w3.org/TR/PNG-Structure.html)
                // The first eight bytes of a PNG file always contain the following (decimal) values:
                // 137 80 78 71 13 10 26 10

                // If the imageData is nil (i.e. if trying to save a UIImage directly or the image was transformed on download)
                // and the image has an alpha channel, we will consider it PNG to avoid losing the transparency
                int alphaInfo = CGImageGetAlphaInfo(image.CGImage);
                BOOL hasAlpha = !(alphaInfo == kCGImageAlphaNone ||
                                  alphaInfo == kCGImageAlphaNoneSkipFirst ||
                                  alphaInfo == kCGImageAlphaNoneSkipLast);
                BOOL imageIsPng = hasAlpha;

                // But if we have an image data, we will look at the preffix
                if ([imageData length] >= [kPNGSignatureData length]) {
                    imageIsPng = ImageDataHasPNGPreffix(imageData);
                }

                if (imageIsPng) {
                    data = UIImagePNGRepresentation(image);
                }
                else {
                    data = UIImageJPEGRepresentation(image, (CGFloat)1.0);
                }
#else
                data = [NSBitmapImageRep representationOfImageRepsInArray:image.representations usingType: NSJPEGFileType properties:nil];
#endif
            }

            if (data) {
                if (![_fileManager fileExistsAtPath:_diskCachePath]) {
                    [_fileManager createDirectoryAtPath:_diskCachePath withIntermediateDirectories:YES attributes:nil error:NULL];
                }

                // get cache Path for image key
                NSString *cachePathForKey = [self defaultCachePathForKey:key];
                // transform to NSUrl
                NSURL *fileURL = [NSURL fileURLWithPath:cachePathForKey];

                [_fileManager createFileAtPath:cachePathForKey contents:data attributes:nil];

                // disable iCloud backup
                if (self.shouldDisableiCloud) {
                    [fileURL setResourceValue:[NSNumber numberWithBool:YES] forKey:NSURLIsExcludedFromBackupKey error:nil];
                }
            }
        });
    }
}

- (void)storeImage:(UIImage *)image forKey:(NSString *)key {
    [self storeImage:image recalculateFromImage:YES imageData:nil forKey:key toDisk:YES];
}

- (void)storeImage:(UIImage *)image forKey:(NSString *)key toDisk:(BOOL)toDisk {
    [self storeImage:image recalculateFromImage:YES imageData:nil forKey:key toDisk:toDisk];
}

存储一个图片到缓存中，可以使用方法 storeImage:forKey:method:，默认，图片既会存储到内存缓存中，也会异步地保存到磁盘缓存中。
如果只想使用内存缓存，可以使用另外一个方法 storeImage:forKey:toDisk，第三个参数传入 false 值就好了。

参考地址：
详情可以参考GCD相关的知识
runtime解析
NSCache的参考资料
runtime的详解